package indi.kider.server.applet.util;

import com.google.common.base.Strings;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

@SuppressWarnings("all")
public class DateTool {
    /**
     * 简单日期格式 yyyyMMdd
     */
    public static final String FORMAT_SIMPLEDATE = "yyyyMMdd";
    /**
     * 简单时间格式 HH:mm:ss
     */
    public static final String FORMAT_SIMPLETIME = "HH:mm:ss";
    /**
     * 简单日期时间格式 yyyyMMdd HH:mm:ss
     */
    public static final String FORMAT_SIMPLEDATETIME = "yyyyMMdd HH:mm:ss";

    /**
     * 简单日期时间格式 yyyy-MM-dd HH:mm:ss
     */
    public static final String FORMAT_COMMON_DATETIME = "yyyy-MM-dd HH:mm:ss";
    /**
     * 简单日期时间格式 yyyy-MM-dd
     */
    public static final String FORMAT_COMMON_DATE= "yyyy-MM-dd";
    /**
     * 得到某个微秒数(距离1970.1.1 00:00:00的微秒值)表示日期时间中的时间，时间格式为“HH:mm:ss” ,例如："10:23:01" 。
     * @param dateTime
     * @return
     */
    public final static String getSimpleTime(long dateTime) {
        Date date = new Date(dateTime);
        return formatDate(date, FORMAT_SIMPLETIME);
    }

    /**
     * 得到一个日期中简单格式(格式为“yyyyMMdd” ,例如："20040101")的年月日
     * @param date
     * @return
     */
    public final static String getSimpleDate(Date date) {
        return formatDate(date, FORMAT_SIMPLEDATE);
    }

    /**
     * 得到简单格式(格式为“yyyyMMdd HH:mm:ss” ,例如："20040101")的年月日 时分秒
     * @param date
     * @return
     */
    public final static String getSimpleDateTime(Date date) {
        return formatDate(date, FORMAT_SIMPLEDATETIME);
    }

    /**
     * 得到一个日期中简单格式(格式为“HH:mm:ss” ,例如："10:23:01")的时间
     * @param date
     * @return
     */
    public final static String getSimpleTime(Date date) {
        return formatDate(date, FORMAT_SIMPLETIME);
    }

    /**
     * 得到指定格式的当前日期
     * @param format
     * @return
     */
    public final static String getCurDate(String format){
        Calendar cal = Calendar.getInstance();
        return formatDate(cal.getTime(), format);
    }
    /**
     * 取得当前日期 yyyy-MM-dd HH:mm:ss
     * @return time
     */
    public static String getCurrentTime() {
        DateFormat f = new SimpleDateFormat(FORMAT_COMMON_DATETIME);
        return f.format(Calendar.getInstance().getTime());
    }

    /**
     * 得到当前时间，格式为pattern，例如HH:mm:ss等。
     * @param pattern String
     * @return String
     * @deprecated
     */
    public final static String getDateTime(Date date, String pattern) {
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        return format.format(date);
    }

    /**
     * 格式                                示例
     "dd/MMM/yyyy"                     06/Mar/1974
     "dd-MM-yyyy"                      06-03-1974
     "dd MMMMMMMMM yyyy"               06 March 1974
     "EEEEEEEEE, MMMMMMMMM dd, yyyy"   Wednesday, March 06, 1974
     有效的SimpleDateFormat显示格式
     表B是SimpleDateFormat参数的缩略语表。
     y   year
     M   month in year
     d   day in month
     D   day in year
     w   week in year
     W   week in month
     E   day in week

     * @param date
     * @param format
     * @return
     */
    public static String formatDate(Date date, String format) {
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        return formatter.format(date);
    }

    /**
     * 把日期String转换为日期对象
     * @param dateStr
     * @param format
     * @return
     * @throws ParseException
     */
    public static Date parserDate(String dateStr, String format) throws ParseException {
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        return formatter.parse(dateStr);
    }

    public static Date changeDate(Date date, String format) throws ParseException {
        String dateStr = formatDate(date,format);
        return parserDate(dateStr,format);
    }

    /**
     * 方法说明：时间的加减。
     * @param today 当前目标日期
     * @param format 当前目标日期的格式
     * @param calendarType 间隔的类型 Calendar.DATE 为天，Calendar.MONTH 	为月
     * @param d 跨度 可以为负
     * @return
     * @throws ParseException
     *
     */
    public static String getTheSpanDate(String today,String format,int calendarType, int d) {
        return getTheSpanDate(today,format,calendarType,d,format);
    }

    /**
     * 方法说明：时间的加减。
     * @param today
     * @param format
     * @param calendarType
     * @param d
     * @param outeFormat
     * @return
     */
    public static String getTheSpanDate(String today,String format,int calendarType, int d,String outeFormat){
        Calendar now = Calendar.getInstance();
        try {
            now.setTime(parserDate(today,format));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        now.set(calendarType, now.get(calendarType) + d);
        return formatDate(now.getTime(),outeFormat);
    }

    /**
     * 方法说明：这个日期的当月的第一天
     * @param day
     * @param format
     * @return
     *
     */
    public static String getTheMonthFirstDate(String day,String format) {
        Calendar now = Calendar.getInstance();
        try {
            now.setTime(parserDate(day,format));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        now.set(Calendar.DATE, 1);
        return formatDate(now.getTime(),format);
    }

    /**
     * 方法说明：获取给定时间的前后日期
     * @param date
     * @param offset 偏移量
     * @param format
     * @return
     */
    public static String getTimeStr(Date date,int offset,String format){
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.DAY_OF_MONTH, offset);
        return formatDate(cal.getTime(),format);
    }

    ////////////////////////////////////////////////////////////////////////////////////////
    /**
     * 时间范围：年
     */
    public static final int YEAR = 1;

    /**
     * 时间范围：季度
     */
    public static final int QUARTER = 2;

    /**
     * 时间范围：月
     */
    public static final int MONTH = 3;

    /**
     * 时间范围：旬
     */
    public static final int TENDAYS = 4;

    /**
     * 时间范围：周
     */
    public static final int WEEK = 5;

    /**
     * 时间范围：日
     */
    public static final int DAY = 6;

    /* 基准时间 */
    private Date fiducialDate = null;

    private Calendar cal = null;

    private DateTool(Date fiducialDate) {
        if (fiducialDate != null) {
            this.fiducialDate = fiducialDate;
        } else {
            this.fiducialDate = new Date(System.currentTimeMillis());
        }
        this.cal = Calendar.getInstance();
        this.cal.setTime(this.fiducialDate);
        this.cal.set(Calendar.HOUR_OF_DAY, 0);
        this.cal.set(Calendar.MINUTE, 0);
        this.cal.set(Calendar.SECOND, 0);
        this.cal.set(Calendar.MILLISECOND, 0);
        this.fiducialDate = this.cal.getTime();
    }

    /**
     * 获取DateHelper实例
     *
     * @param fiducialDate 基准时间
     * @return Date
     */

    public static DateTool getInstance(Date fiducialDate) {
        return new DateTool(fiducialDate);
    }

    /**
     * 获取DateHelper实例, 使用当前时间作为基准时间
     *
     * @return Date
     */

    public static DateTool getInstance() {
        return new DateTool(null);
    }

    /**
     * 获取年的第一天
     *
     * @param offset 偏移量
     * @return Date
     */

    public Date getFirstDayOfYear(int offset) {
        cal.setTime(this.fiducialDate);
        cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + offset);
        cal.set(Calendar.MONTH, Calendar.JANUARY);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        return cal.getTime();
    }

    /**
     * 获取年的最后一天
     *
     * @param offset 偏移量
     * @return Date
     */

    public Date getLastDayOfYear(int offset) {
        cal.setTime(this.fiducialDate);
        cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + offset);
        cal.set(Calendar.MONTH, Calendar.DECEMBER);
        cal.set(Calendar.DAY_OF_MONTH, 31);
        return cal.getTime();
    }

    /**
     * 获取季度的第一天
     *
     * @param offset 偏移量
     * @return Date
     */

    public Date getFirstDayOfQuarter(int offset) {
        cal.setTime(this.fiducialDate);
        cal.add(Calendar.MONTH, offset * 3);
        int mon = cal.get(Calendar.MONTH);
        if (mon >= Calendar.JANUARY && mon <= Calendar.MARCH) {
            cal.set(Calendar.MONTH, Calendar.JANUARY);
            cal.set(Calendar.DAY_OF_MONTH, 1);
        }

        if (mon >= Calendar.APRIL && mon <= Calendar.JUNE) {
            cal.set(Calendar.MONTH, Calendar.APRIL);
            cal.set(Calendar.DAY_OF_MONTH, 1);
        }
        if (mon >= Calendar.JULY && mon <= Calendar.SEPTEMBER) {
            cal.set(Calendar.MONTH, Calendar.JULY);
            cal.set(Calendar.DAY_OF_MONTH, 1);
        }
        if (mon >= Calendar.OCTOBER && mon <= Calendar.DECEMBER) {
            cal.set(Calendar.MONTH, Calendar.OCTOBER);
            cal.set(Calendar.DAY_OF_MONTH, 1);
        }
        return cal.getTime();
    }

    public Date getYesterday() {
        long time = this.fiducialDate.getTime() - 60 * 60 * 24 * 1000;
        return new Date(time);

    }

    public Date getTomorrow() {
        long time = this.fiducialDate.getTime() + 60 * 60 * 24 * 1000;
        return new Date(time);
    }

    /**
     * 获取季度的最后一天
     *
     * @param offset 偏移量
     * @return Date
     */
    public Date getLastDayOfQuarter(int offset) {
        cal.setTime(this.fiducialDate);
        cal.add(Calendar.MONTH, offset * 3);
        int mon = cal.get(Calendar.MONTH);
        if (mon >= Calendar.JANUARY && mon <= Calendar.MARCH) {
            cal.set(Calendar.MONTH, Calendar.MARCH);
            cal.set(Calendar.DAY_OF_MONTH, 31);
        }
        if (mon >= Calendar.APRIL && mon <= Calendar.JUNE) {
            cal.set(Calendar.MONTH, Calendar.JUNE);
            cal.set(Calendar.DAY_OF_MONTH, 30);
        }
        if (mon >= Calendar.JULY && mon <= Calendar.SEPTEMBER) {
            cal.set(Calendar.MONTH, Calendar.SEPTEMBER);
            cal.set(Calendar.DAY_OF_MONTH, 30);
        }
        if (mon >= Calendar.OCTOBER && mon <= Calendar.DECEMBER) {
            cal.set(Calendar.MONTH, Calendar.DECEMBER);
            cal.set(Calendar.DAY_OF_MONTH, 31);
        }
        return cal.getTime();
    }

    /**
     * 获取月的第一天
     *
     * @param offset 偏移量
     * @return Date
     */
    public Date getFirstDayOfMonth(int offset) {
        cal.setTime(this.fiducialDate);
        cal.add(Calendar.MONTH, offset);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        return cal.getTime();
    }

    /**
     * 获取月的最后一天
     *
     * @param offset 偏移量
     * @return Date
     */

    public Date getLastDayOfMonth(int offset) {
        cal.setTime(this.fiducialDate);
        cal.add(Calendar.MONTH, offset + 1);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        cal.add(Calendar.DAY_OF_MONTH, -1);
        return cal.getTime();
    }

    /**
     * 获取旬的第一天
     *
     * @param offset 偏移量
     * @return Date
     */

    public Date getFirstDayOfTendays(int offset) {
        cal.setTime(this.fiducialDate);
        int day = cal.get(Calendar.DAY_OF_MONTH);
        if (day >= 21) {
            day = 21;
        } else if (day >= 11) {
            day = 11;
        } else {
            day = 1;
        }
        if (offset > 0) {
            day = day + 10 * offset;
            int monOffset = day / 30;
            day = day % 30;
            cal.add(Calendar.MONTH, monOffset);
            cal.set(Calendar.DAY_OF_MONTH, day);
        } else {
            int monOffset = 10 * offset / 30;
            int dayOffset = 10 * offset % 30;
            if ((day + dayOffset) > 0) {
                day = day + dayOffset;
            } else {
                monOffset = monOffset - 1;
                day = day - dayOffset - 10;
            }
            cal.add(Calendar.MONTH, monOffset);
            cal.set(Calendar.DAY_OF_MONTH, day);
        }
        return cal.getTime();
    }

    /**
     * 获取旬的最后一天
     *
     * @param offset 偏移量
     * @return Date
     */
    public Date getLastDayOfTendays(int offset) {
        Date date = getFirstDayOfTendays(offset + 1);
        cal.setTime(date);
        cal.add(Calendar.DAY_OF_MONTH, -1);
        return cal.getTime();
    }

    /**
     * 获取周的第一天(MONDAY)
     *
     * @param offset 偏移量
     * @return Date
     */
    public Date getFirstDayOfWeek(int offset) {
        cal.setTime(this.fiducialDate);
        cal.add(Calendar.DAY_OF_MONTH, offset * 7);
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        return cal.getTime();
    }

    /**
     * 获取周的最后一天(SUNDAY)
     *
     * @param offset 偏移量
     * @return Date
     */
    public Date getLastDayOfWeek(int offset) {
        cal.setTime(this.fiducialDate);
        cal.add(Calendar.DAY_OF_MONTH, offset * 7);
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        cal.add(Calendar.DAY_OF_MONTH, 6);
        return cal.getTime();
    }

    /**
     * 根据日历的规则，为基准时间添加指定日历字段的时间量
     *
     * @param field  日历字段, 使用Calendar类定义的日历字段常量
     * @param offset 偏移量
     * @return Date
     */
    public Date add(int field, int offset) {
        cal.setTime(this.fiducialDate);
        cal.add(field, offset);
        return cal.getTime();
    }

    /**
     * 根据日历的规则，为基准时间添加指定日历字段的单个时间单元
     *
     * @param field 日历字段, 使用Calendar类定义的日历字段常量
     * @param up    指定日历字段的值的滚动方向。true:向上滚动 / false:向下滚动
     * @return Date
     */
    public Date roll(int field, boolean up) {
        cal.setTime(this.fiducialDate);
        cal.roll(field, up);
        return cal.getTime();
    }

    /**
     * 把字符串转换为日期
     *
     * @param dateStr 日期字符串
     * @param format  日期格式
     * @return Date
     */
    public static Date strToDate(String dateStr, String format) {
        Date date = null;
        if (dateStr != null && (!dateStr.equals(""))) {
            DateFormat df = new SimpleDateFormat(format);
            try {
                date = df.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return date;
    }

    /**
     * 把字符串转换为日期，日期的格式为 yyyy-MM-dd HH:ss
     * @param dateStr 日期字符串
     * @return Date
     */
    public static Date strToDate(String dateStr) {
        Date date = null;
        if (dateStr != null && (!dateStr.equals(""))) {
            if (dateStr.matches("\\d{4}-\\d{1,2}-\\d{1,2}")) {
                dateStr = dateStr + " 00:00";
            } else if (dateStr.matches("\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}")) {
                dateStr = dateStr + ":00";
            } else {
                System.out.println(dateStr + " 格式不正确");
                return null;
            }
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:ss");
            try {
                date = df.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return date;
    }

    /**
     * 把日期转换为字符串 yyyy-MM-dd hh:mm:ss
     *
     * @param date   日期实例
     * @param format 日期格式
     * @return Date
     */
    public static String dateToStr(Date date, String format) {
        return (date == null) ? "" : new SimpleDateFormat(format).format(date);
    }

    public static String dateToStr(Date date) {
        return (date == null) ? ""
                : new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);

    }

    /**
     * 根据指定日期获取相应的间隔日期
     * @param type 间隔类型  1 年 2 月 3 日
     * @param formate 返回的格式
     * @param currDate 指定的初始日期
     * @param intervalNum  间隔的数量
     * @return
     */
    public static String getIntervalDate(int type, String formate,Date currDate,int intervalNum){
        Calendar cal = Calendar.getInstance();
        cal.setTime(currDate);//设置起时间
       switch (type){
           case 1:
               cal.add(Calendar.YEAR, intervalNum);
               break;
           case 2:
               cal.add(Calendar.MONTH, intervalNum);
               break;
           case 3:
               cal.add(Calendar.DATE, intervalNum);
               break;
       }
        return formatDate(cal.getTime(),formate);
    }

    /**
     * 取得当前日期 年-月-日
     *
     * @return Date
     */
    public static String getCurrentDate() {
        DateFormat f = new SimpleDateFormat("yyyy-MM-dd");
        return f.format(Calendar.getInstance().getTime());
    }

    /**
     * 取当前日期的字符串形式,"XXXX年XX月XX日"
     *
     * @return java.lang.String
     */
    public static String getPrintDate() {
        String printDate = "";
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        printDate += calendar.get(Calendar.YEAR) + "年";
        printDate += (calendar.get(Calendar.MONTH) + 1) + "月";
        printDate += calendar.get(Calendar.DATE) + "日";
        return printDate;
    }

    /**
     * 将指定的日期字符串转化为日期对象
     *
     * @param dateStr 日期字符串
     * @return java.util.Date
     */
    public static Date getDate(String dateStr, String format) {
        if (dateStr == null) {
            return new Date();
        }
        if (format == null) {
            format = "yyyy-MM-dd";
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            Date date = sdf.parse(dateStr);
            return date;
        } catch (Exception e) {
            return null;
        }

    }

    /**
     * 从指定Timestamp中得到相应的日期的字符串形式 日期"XXXX-XX-XX"
     *
     * @param dateTime
     * @return 、String
     */
    public static String getDateFromDateTime(Timestamp dateTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(dateTime).toString();
    }

    /**
     * 得到当前时间 return java.sql.Timestamp
     * @return Timestamp
     */
    public static Timestamp getNowTimestamp() {
        long curTime = System.currentTimeMillis();
        return new Timestamp(curTime);
    }
    /**
     * 得到当前时间
     * @return Date
     */
    public static Date getNowDate() {
        long curTime = System.currentTimeMillis();
        return new Date(curTime);
    }

    /**
     * 获得当前月--开始日期
     * @param date	当前时间
     * @return		当前月开始日期（yyyy-MM-dd）
     */
    public static String getMinMonthDate(Date date) {
        return getMinMonthDate(date,"yyyy-MM-dd");
    }
    /**
     * 获得当前月--开始日期
     * @param date	当前时间
     * @return		当前月开始日期（yyyy-MM-dd）
     */
    public static String getMinMonthDate(Date date, String format) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        Calendar calendar = Calendar.getInstance();
        try {
            calendar.setTime(date);
            calendar.set(Calendar.DAY_OF_MONTH,
                    calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
            return dateFormat.format(calendar.getTime());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }
    /**
     * 获得当前月--结束日期
     * @param date	当前时间
     * @return		当前月结束日期（yyyy-MM-dd）
     */
    public static String getMaxMonthDate(Date date) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        try {
            calendar.setTime(date);
            calendar.set(Calendar.DAY_OF_MONTH,
                    calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
            return dateFormat.format(calendar.getTime());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 相差天数
     * @param startDate
     * @param endDate
     * @return
     */
    public static Long getDaysBetween(Date startDate, Date endDate) {
        Calendar fromCalendar = Calendar.getInstance();
        fromCalendar.setTime(startDate);
        fromCalendar.set(Calendar.HOUR_OF_DAY, 0);
        fromCalendar.set(Calendar.MINUTE, 0);
        fromCalendar.set(Calendar.SECOND, 0);
        fromCalendar.set(Calendar.MILLISECOND, 0);

        Calendar toCalendar = Calendar.getInstance();
        toCalendar.setTime(endDate);
        toCalendar.set(Calendar.HOUR_OF_DAY, 0);
        toCalendar.set(Calendar.MINUTE, 0);
        toCalendar.set(Calendar.SECOND, 0);
        toCalendar.set(Calendar.MILLISECOND, 0);

        return (toCalendar.getTime().getTime() - fromCalendar.getTime()
                .getTime())
                / (1000 * 60 * 60 * 24);
    }

    /**
     * 获取两个日期相隔的的天数
     * @param beginDateStr	开始时间
     * @param endDateStr	结束时间
     * @return
     */
    public static long getDaySub(String beginDateStr, String endDateStr) {
        long day = 0;
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date beginDate;
        Date endDate;
        try {
            beginDate = format.parse(beginDateStr);
            endDate = format.parse(endDateStr);
            day = (endDate.getTime() - beginDate.getTime()) / (24 * 60 * 60 * 1000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return day;
    }

    /**
     * 日期加减（仅支持天数加减）
     * @param date		需要运算的日期
     * @param days		需要加减的天数（正为加，负为减）
     * @return
     */
    public static String addOrMinusDays(Date date,int days){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dt = addOrMinusDaysDate(date, days);
        String result = sdf.format(dt);
        System.out.println(result);
        return result;
    }

    /**
     * 日期加减（仅支持天数加减）
     * @param date		需要运算的日期
     * @param days		需要加减的天数（正为加，负为减）
     * @return
     */
    public static Date addOrMinusDaysDate(Date date,int days){
        Calendar rightNow = Calendar.getInstance();
        rightNow.setTime(date);
        rightNow.add(Calendar.DAY_OF_YEAR,days);
        Date dt = rightNow.getTime();
        return dt;
    }

    /**
     * 获取某年某月的最后一天
     * @param year		年份
     * @param month		月份
     * @return			返回格式化后的时间字符串，例如：2016-5-31
     */
    public static String getLastDayOfMonth(int year, int month){
        Calendar cal = Calendar.getInstance();
        //设置年份
        cal.set(Calendar.YEAR,year);
        //设置月份
        cal.set(Calendar.MONTH, month-1);
        //获取某月最大天数
        int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        //设置日历中月份的最大天数
        cal.set(Calendar.DAY_OF_MONTH, lastDay);
        //二月的处理
        int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
        if(dayOfMonth == 2){
            cal.set(Calendar.MONTH, month-1);
            cal.set(Calendar.DAY_OF_MONTH, 29);
        }else if(dayOfMonth == 3){
            cal.set(Calendar.MONTH, month-1);
            cal.set(Calendar.DAY_OF_MONTH, 28);
        }
        //格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String lastDayOfMonth = sdf.format(cal.getTime());

        return lastDayOfMonth;
    }
    /**
     * 获取当天开始时间
     * yyyy/mm/dd hh:MM:ss
     */
    public static String getCurrentDateStart(){
        String date=getCurDate("yyyy/MM/dd");
        return  date+" "+"00:00:00" ;
    }
    /**
     * 获取当天结束时间
     * yyyy/mm/dd hh:MM:ss
     */
    public static String getCurrentDateEnd(){
        String date=getCurDate("yyyy/MM/dd");
        return  date+" "+"23:59:59" ;
    }


    /**
     * 校验数据和时间格式是否匹配
     * @param dateStr
     * @param format
     * @return
     */
    public static boolean isValidDate(String dateStr, String format) {
        //dateStr 为空时
        if (Strings.isNullOrEmpty(dateStr)){
            return false;
        }
        boolean convertSuccess=true;
        // 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；
        SimpleDateFormat fmt = new SimpleDateFormat(format);
        try {
            // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
            fmt.setLenient(false);
            fmt.parse(dateStr);
        } catch (ParseException e) {
            // e.printStackTrace();
            // 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
            convertSuccess=false;
        }
        return convertSuccess;
    }
}
